{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch Normalization\n",
    "One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \n",
    "One idea along these lines is batch normalization which was proposed by [3] in 2015.\n",
    "\n",
    "The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n",
    "\n",
    "The authors of [3] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [3] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n",
    "\n",
    "It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n",
    "\n",
    "[3] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
    "Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n",
    "\n",
    "def print_mean_std(x,axis=0):\n",
    "    print('  means: ', x.mean(axis=axis))\n",
    "    print('  stds:  ', x.std(axis=axis))\n",
    "    print('') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('y_train: ', (49000,))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.items():\n",
    "  print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: forward\n",
    "In the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n",
    "\n",
    "Referencing the paper linked to above would be helpful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before batch normalization:\n",
      "('  means: ', array([ -2.3814598 , -13.18038246,   1.91780462]))\n",
      "('  stds:  ', array([27.18502186, 34.21455511, 37.68611762]))\n",
      "\n",
      "After batch normalization (gamma=1, beta=0)\n",
      "('  means: ', array([5.32907052e-17, 5.49560397e-17, 9.71445147e-18]))\n",
      "('  stds:  ', array([0.99999999, 1.        , 1.        ]))\n",
      "\n",
      "('After batch normalization (gamma=', array([1., 2., 3.]), ', beta=', array([11., 12., 13.]), ')')\n",
      "('  means: ', array([11., 12., 13.]))\n",
      "('  stds:  ', array([0.99999999, 1.99999999, 2.99999999]))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after batch normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before batch normalization:')\n",
    "print_mean_std(a,axis=0)\n",
    "\n",
    "gamma = np.ones((D3,))\n",
    "beta = np.zeros((D3,))\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After batch normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)\n",
    "\n",
    "gamma = np.asarray([1.0, 2.0, 3.0])\n",
    "beta = np.asarray([11.0, 12.0, 13.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After batch normalization (test-time):\n",
      "('  means: ', array([-0.03927354, -0.04349152, -0.10452688]))\n",
      "('  stds:  ', array([1.01531428, 1.01238373, 0.97819988]))\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "# Check the test-time forward pass by running the training-time\n",
    "# forward pass many times to warm up the running averages, and then\n",
    "# checking the means and variances of activations after a test-time\n",
    "# forward pass.\n",
    "\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "\n",
    "for t in range(50):\n",
    "  X = np.random.randn(N, D1)\n",
    "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "  batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "bn_param['mode'] = 'test'\n",
    "X = np.random.randn(N, D1)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "# Means should be close to zero and stds close to one, but will be\n",
    "# noisier than training-time forward passes.\n",
    "print('After batch normalization (test-time):')\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: backward\n",
    "Now implement the backward pass for batch normalization in the function `batchnorm_backward`.\n",
    "\n",
    "To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n",
    "\n",
    "Once you have finished, run the following to numerically check your backward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('dx error: ', 1.7029275364845641e-09)\n",
      "('dgamma error: ', 7.420414216247087e-13)\n",
      "('dbeta error: ', 2.8795057655839487e-12)\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
    "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
    "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
    "#You should expect to see relative errors between 1e-13 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: alternative backward\n",
    "In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n",
    "\n",
    "Surprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too.  \n",
    "Given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n",
    "we first calculate the mean $\\mu=\\frac{1}{N}\\sum_{k=1}^N x_k$ and variance $v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2.$    \n",
    "With $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma=\\sqrt{v+\\epsilon}$  and normalized data $Y$ with $y_i=\\frac{x_i-\\mu}{\\sigma}.$\n",
    "\n",
    "\n",
    "The meat of our problem is to get $\\frac{\\partial L}{\\partial X}$ from the upstream gradient $\\frac{\\partial L}{\\partial Y}.$ It might be challenging to directly reason about the gradients over $X$ and $Y$ - try reasoning about it in terms of $x_i$ and $y_i$ first.\n",
    "\n",
    "You will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. You should make sure each of the intermediary steps are all as simple as possible. \n",
    "\n",
    "After doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('dx difference: ', 3.0666812374106965e-13)\n",
      "('dgamma difference: ', 0.0)\n",
      "('dbeta difference: ', 0.0)\n",
      "speedup: 1.26x\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D = 100, 500\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "\n",
    "t1 = time.time()\n",
    "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
    "t2 = time.time()\n",
    "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
    "t3 = time.time()\n",
    "\n",
    "print('dx difference: ', rel_error(dx1, dx2))\n",
    "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
    "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
    "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fully Connected Nets with Batch Normalization\n",
    "Now that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n",
    "\n",
    "Concretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n",
    "\n",
    "HINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Running check with reg = ', 0)\n",
      "('Initial loss: ', 2.2611955101340957)\n",
      "W1 relative error: 1.10e-04\n",
      "W2 relative error: 2.85e-06\n",
      "W3 relative error: 4.05e-10\n",
      "b1 relative error: 2.22e-07\n",
      "b2 relative error: 2.22e-08\n",
      "b3 relative error: 1.01e-10\n",
      "beta1 relative error: 7.33e-09\n",
      "beta2 relative error: 1.89e-09\n",
      "gamma1 relative error: 6.96e-09\n",
      "gamma2 relative error: 1.96e-09\n",
      "()\n",
      "('Running check with reg = ', 3.14)\n",
      "('Initial loss: ', 6.996533220108303)\n",
      "W1 relative error: 1.98e-06\n",
      "W2 relative error: 2.28e-06\n",
      "W3 relative error: 1.11e-08\n",
      "b1 relative error: 1.67e-08\n",
      "b2 relative error: 8.22e-07\n",
      "b3 relative error: 1.73e-10\n",
      "beta1 relative error: 6.65e-09\n",
      "beta2 relative error: 3.48e-09\n",
      "gamma1 relative error: 8.80e-09\n",
      "gamma2 relative error: 5.28e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "# You should expect losses between 1e-4~1e-10 for W, \n",
    "# losses between 1e-08~1e-10 for b,\n",
    "# and losses between 1e-08~1e-09 for beta and gammas.\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64,\n",
    "                            normalization='batchnorm')\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "    \n",
    "  # print(grads['gamma2'])\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    # print(name, grad_num.shape, 'my grads', grads[name].shape)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
    "  if reg == 0: print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batchnorm for deep networks\n",
    "Run the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 200) loss: 2.340975\n",
      "(Epoch 0 / 10) train acc: 0.107000; val_acc: 0.115000\n",
      "(Epoch 1 / 10) train acc: 0.333000; val_acc: 0.265000\n",
      "(Iteration 21 / 200) loss: 1.999443\n",
      "(Epoch 2 / 10) train acc: 0.425000; val_acc: 0.298000\n",
      "(Iteration 41 / 200) loss: 2.052620\n",
      "(Epoch 3 / 10) train acc: 0.453000; val_acc: 0.294000\n",
      "(Iteration 61 / 200) loss: 1.810844\n",
      "(Epoch 4 / 10) train acc: 0.519000; val_acc: 0.305000\n",
      "(Iteration 81 / 200) loss: 1.331293\n",
      "(Epoch 5 / 10) train acc: 0.578000; val_acc: 0.302000\n",
      "(Iteration 101 / 200) loss: 1.385208\n",
      "(Epoch 6 / 10) train acc: 0.607000; val_acc: 0.329000\n",
      "(Iteration 121 / 200) loss: 1.231006\n",
      "(Epoch 7 / 10) train acc: 0.666000; val_acc: 0.311000\n",
      "(Iteration 141 / 200) loss: 1.193788\n",
      "(Epoch 8 / 10) train acc: 0.685000; val_acc: 0.339000\n",
      "(Iteration 161 / 200) loss: 0.769957\n",
      "(Epoch 9 / 10) train acc: 0.744000; val_acc: 0.336000\n",
      "(Iteration 181 / 200) loss: 1.096398\n",
      "(Epoch 10 / 10) train acc: 0.784000; val_acc: 0.310000\n",
      "(Iteration 1 / 200) loss: 2.302332\n",
      "(Epoch 0 / 10) train acc: 0.126000; val_acc: 0.130000\n",
      "(Epoch 1 / 10) train acc: 0.235000; val_acc: 0.199000\n",
      "(Iteration 21 / 200) loss: 2.115901\n",
      "(Epoch 2 / 10) train acc: 0.296000; val_acc: 0.249000\n",
      "(Iteration 41 / 200) loss: 1.897200\n",
      "(Epoch 3 / 10) train acc: 0.351000; val_acc: 0.291000\n",
      "(Iteration 61 / 200) loss: 1.730721\n",
      "(Epoch 4 / 10) train acc: 0.389000; val_acc: 0.298000\n",
      "(Iteration 81 / 200) loss: 1.531783\n",
      "(Epoch 5 / 10) train acc: 0.426000; val_acc: 0.274000\n",
      "(Iteration 101 / 200) loss: 1.532540\n",
      "(Epoch 6 / 10) train acc: 0.492000; val_acc: 0.319000\n",
      "(Iteration 121 / 200) loss: 1.335824\n",
      "(Epoch 7 / 10) train acc: 0.534000; val_acc: 0.330000\n",
      "(Iteration 141 / 200) loss: 1.322314\n",
      "(Epoch 8 / 10) train acc: 0.583000; val_acc: 0.333000\n",
      "(Iteration 161 / 200) loss: 1.244997\n",
      "(Epoch 9 / 10) train acc: 0.605000; val_acc: 0.317000\n",
      "(Iteration 181 / 200) loss: 1.124863\n",
      "(Epoch 10 / 10) train acc: 0.686000; val_acc: 0.331000\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [100, 100, 100, 100, 100]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2\n",
    "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "bn_solver = Solver(bn_model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True,print_every=20)\n",
    "bn_solver.train()\n",
    "\n",
    "solver = Solver(model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=20)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3QAAANsCAYAAAATFepNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f34dcb77410>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n",
    "    \"\"\"utility function for plotting training history\"\"\"\n",
    "    plt.title(title)\n",
    "    plt.xlabel(label)\n",
    "    bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n",
    "    bl_plot = plot_fn(baseline)\n",
    "    num_bn = len(bn_plots)\n",
    "    for i in range(num_bn):\n",
    "        label='with_norm'\n",
    "        if labels is not None:\n",
    "            label += str(labels[i])\n",
    "        plt.plot(bn_plots[i], bn_marker, label=label)\n",
    "    label='baseline'\n",
    "    if labels is not None:\n",
    "        label += str(labels[0])\n",
    "    plt.plot(bl_plot, bl_marker, label=label)\n",
    "    plt.legend(loc='lower center', ncol=num_bn+1) \n",
    "\n",
    "    \n",
    "plt.subplot(3, 1, 1)\n",
    "plot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n",
    "                      lambda x: x.loss_history, bl_marker='o', bn_marker='o')\n",
    "plt.subplot(3, 1, 2)\n",
    "plot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "plt.subplot(3, 1, 3)\n",
    "plot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and initialization\n",
    "We will now run a small experiment to study the interaction of batch normalization and weight initialization.\n",
    "\n",
    "The first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running weight scale 1 / 20\n",
      "Running weight scale 2 / 20\n",
      "Running weight scale 3 / 20\n",
      "Running weight scale 4 / 20\n",
      "Running weight scale 5 / 20\n",
      "Running weight scale 6 / 20\n",
      "Running weight scale 7 / 20\n",
      "Running weight scale 8 / 20\n",
      "Running weight scale 9 / 20\n",
      "Running weight scale 10 / 20\n",
      "Running weight scale 11 / 20\n",
      "Running weight scale 12 / 20\n",
      "Running weight scale 13 / 20\n",
      "Running weight scale 14 / 20\n",
      "Running weight scale 15 / 20\n",
      "Running weight scale 16 / 20\n",
      "Running weight scale 17 / 20\n",
      "Running weight scale 18 / 20\n",
      "Running weight scale 19 / 20\n",
      "Running weight scale 20 / 20\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "bn_solvers_ws = {}\n",
    "solvers_ws = {}\n",
    "weight_scales = np.logspace(-4, 0, num=20)\n",
    "for i, weight_scale in enumerate(weight_scales):\n",
    "  print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
    "  bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "  model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "  bn_solver = Solver(bn_model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  bn_solver.train()\n",
    "  bn_solvers_ws[weight_scale] = bn_solver\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  solver.train()\n",
    "  solvers_ws[weight_scale] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Plot results of weight scale experiment\n",
    "best_train_accs, bn_best_train_accs = [], []\n",
    "best_val_accs, bn_best_val_accs = [], []\n",
    "final_train_loss, bn_final_train_loss = [], []\n",
    "\n",
    "for ws in weight_scales:\n",
    "  best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n",
    "  bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n",
    "  \n",
    "  best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n",
    "  bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n",
    "  \n",
    "  final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n",
    "  bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n",
    "  \n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Best val accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best val accuracy')\n",
    "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
    "plt.legend(ncol=2, loc='lower right')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Best train accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best training accuracy')\n",
    "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Final training loss vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Final training loss')\n",
    "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "plt.gca().set_ylim(1.0, 3.5)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1:\n",
    "Describe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and batch size\n",
    "We will now run a small experiment to study the interaction of batch normalization and batch size.\n",
    "\n",
    "The first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def run_batchsize_experiments(normalization_mode):\n",
    "    np.random.seed(231)\n",
    "    # Try training a very deep net with batchnorm\n",
    "    hidden_dims = [100, 100, 100, 100, 100]\n",
    "    num_train = 1000\n",
    "    small_data = {\n",
    "      'X_train': data['X_train'][:num_train],\n",
    "      'y_train': data['y_train'][:num_train],\n",
    "      'X_val': data['X_val'],\n",
    "      'y_val': data['y_val'],\n",
    "    }\n",
    "    n_epochs=10\n",
    "    weight_scale = 2e-2\n",
    "    batch_sizes = [5,10,50]\n",
    "    lr = 10**(-3.5)\n",
    "    solver_bsize = batch_sizes[0]\n",
    "\n",
    "    print('No normalization: batch size = ',solver_bsize)\n",
    "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=n_epochs, batch_size=solver_bsize,\n",
    "                    update_rule='adam',\n",
    "                    optim_config={\n",
    "                      'learning_rate': lr,\n",
    "                    },\n",
    "                    verbose=False)\n",
    "    solver.train()\n",
    "    \n",
    "    bn_solvers = []\n",
    "    for i in range(len(batch_sizes)):\n",
    "        b_size=batch_sizes[i]\n",
    "        print('Normalization: batch size = ',b_size)\n",
    "        bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n",
    "        bn_solver = Solver(bn_model, small_data,\n",
    "                        num_epochs=n_epochs, batch_size=b_size,\n",
    "                        update_rule='adam',\n",
    "                        optim_config={\n",
    "                          'learning_rate': lr,\n",
    "                        },\n",
    "                        verbose=False)\n",
    "        bn_solver.train()\n",
    "        bn_solvers.append(bn_solver)\n",
    "        \n",
    "    return bn_solvers, solver, batch_sizes\n",
    "\n",
    "batch_sizes = [5,10,50]\n",
    "bn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 2:\n",
    "Describe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n",
    "\n",
    "## Answer:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization\n",
    "Batch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n",
    "\n",
    "Several alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [4]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n",
    "\n",
    "[4] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 3:\n",
    "Which of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n",
    "\n",
    "1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n",
    "2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1.  \n",
    "3. Subtracting the mean image of the dataset from each image in the dataset.\n",
    "4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n",
    "\n",
    "## Answer:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization: Implementation\n",
    "\n",
    "Now you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n",
    "\n",
    "Here's what you need to do:\n",
    "\n",
    "* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the cell below to check your results.\n",
    "* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the second cell below to check your results.\n",
    "* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n",
    "\n",
    "Run the third cell below to run the batch size experiment on layer normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before layer normalization:\n",
      "('  means: ', array([-52.24517198, -42.86302086, -37.18869497]))\n",
      "('  stds:  ', array([14.94837509, 25.33280868, 32.52972376]))\n",
      "()\n",
      "After layer normalization (gamma=1, beta=0)\n",
      "('  means: ', array([ 2.22044605e-16, -1.66533454e-16,  5.55111512e-17]))\n",
      "('  stds:  ', array([0.99999998, 0.99999999, 1.        ]))\n",
      "()\n",
      "('After layer normalization (gamma=', array([3., 3., 3.]), ', beta=', array([5., 5., 5.]), ')')\n",
      "('  means: ', array([5., 5., 5.]))\n",
      "('  stds:  ', array([2.99999993, 2.99999998, 2.99999999]))\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after layer normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 =4, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before layer normalization:')\n",
    "print_mean_std(a,axis=0)  # 这里有误, 原来是axis=1\n",
    "\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "# Means should be close to zero and stds close to one\n",
    "# print('a.shape, gamma.shape, beta.shape: ', a.shape, gamma.shape, beta.shape)\n",
    "print('After layer normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "\n",
    "print_mean_std(a_norm, axis=0) # 这里有误, 原来是axis=1\n",
    "\n",
    "gamma = np.asarray([3.0,3.0,3.0])\n",
    "beta = np.asarray([5.0,5.0,5.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0) # 这里有误, 原来是axis=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('dx error: ', 1.7029255488709078e-09)\n",
      "('dgamma error: ', 7.420414216247087e-13)\n",
      "('dbeta error: ', 2.8795057655839487e-12)\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "ln_param = {}\n",
    "fx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\n",
    "fg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\n",
    "fb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = layernorm_forward(x, gamma, beta, ln_param)\n",
    "dx, dgamma, dbeta = layernorm_backward(dout, cache)\n",
    "\n",
    "#You should expect to see relative errors between 1e-12 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization and batch size\n",
    "\n",
    "We will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'run_batchsize_experiments' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-6dcf33dd8d2d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mln_solvers_bsize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolver_bsize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun_batchsize_experiments\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'layernorm'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mplot_training_history\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Training accuracy (Layer Normalization)'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'Epoch'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msolver_bsize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mln_solvers_bsize\u001b[0m\u001b[0;34m,\u001b[0m                       \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_acc_history\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbl_marker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'-^'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbn_marker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'-o'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbatch_sizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'run_batchsize_experiments' is not defined"
     ]
    }
   ],
   "source": [
    "ln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 4:\n",
    "When is layer normalization likely to not work well, and why?\n",
    "\n",
    "1. Using it in a very deep network\n",
    "2. Having a very small dimension of features\n",
    "3. Having a high regularization term\n",
    "\n",
    "\n",
    "## Answer:\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
